home *** CD-ROM | disk | FTP | other *** search
/ Mac Power 1997 December / MACPOWER-1997-12.ISO.7z / MACPOWER-1997-12.ISO / AMUG / PROGRAMMING / Raven 1.2.sit / Raven 1.2 / Source / Foundation / Common / ZGeometry.cpp < prev    next >
Text File  |  1997-07-24  |  9KB  |  333 lines
  1. /*
  2.  *  File:       ZGeometry.h
  3.  *  Summary:    Point, size, and rectangle classes.
  4.  *  Written by: Jesse Jones
  5.  *
  6.  *  Copyright ｩ 1996-1997 Jesse Jones. 
  7.  *    For conditions of distribution and use, see copyright notice in ZTypes.h  
  8.  *
  9.  *  Change History (most recent first):    
  10.  *
  11.  *         <4>      6/17/97    JDJ        TLongRect::MapTo uses longs instead of shorts.
  12.  *         <3>      3/19/97    JDJ        Pin methods pin to botRight instead of botRight
  13.  *                                    minus one.
  14.  *         <2>      3/11/97    JDJ        Made Pin methods const.
  15.  *         <1>      1/14/96    JDJ        Created.
  16.  */
  17.  
  18. #include <ZGeometry.h>
  19.  
  20. #include <Fp.h>
  21.  
  22. #include <ZNumbers.h>
  23.  
  24.  
  25. //-----------------------------------
  26. //    Constants
  27. //
  28. const TPoint         kZeroPt(0, 0);
  29. const TSize          kZeroSize(0, 0);
  30. const TRect          kZeroRect(0, 0, 0, 0);
  31.  
  32. const TLongPoint    kLongZeroPt(0, 0);
  33. const TLongSize      kLongZeroSize(0, 0);
  34. const TLongRect      kLongZeroRect(0, 0, 0, 0);
  35.  
  36.  
  37. //-----------------------------------
  38. //    STL specializations
  39. //
  40. DEFINE_STL_FUNCTIONS(TPoint);
  41. DEFINE_STL_FUNCTIONS(TSize);
  42. DEFINE_STL_FUNCTIONS(TRect);
  43. DEFINE_STL_FUNCTIONS(TLongPoint);
  44. DEFINE_STL_FUNCTIONS(TLongSize);
  45. DEFINE_STL_FUNCTIONS(TLongRect);
  46.  
  47.  
  48. // ===================================================================================
  49. //    class TPoint
  50. // ===================================================================================
  51.  
  52. //---------------------------------------------------------------
  53. //
  54. // TPoint::operator*
  55. //
  56. //---------------------------------------------------------------
  57. TPoint operator*(short num, const TPoint& pt)
  58. {
  59.     return TPoint((short) (pt.h*num), (short) (pt.v*num));
  60. }
  61.  
  62. #pragma mark -
  63.  
  64. // ===================================================================================
  65. //    class TSize
  66. // ===================================================================================
  67.  
  68. //---------------------------------------------------------------
  69. //
  70. // TSize::operator*
  71. //
  72. //---------------------------------------------------------------
  73. TSize operator*(short num, const TSize& size)
  74. {
  75.     return TSize((short) (size.width*num), (short) (size.height*num));
  76. }
  77.  
  78. #pragma mark -
  79.  
  80. // ===================================================================================
  81. //    class TRect
  82. // ===================================================================================
  83.  
  84. //---------------------------------------------------------------
  85. //
  86. // TRect::operator|
  87. //
  88. //---------------------------------------------------------------
  89. TRect TRect::operator|(const TRect& rect) const
  90. {
  91.     TRect returnRect;
  92.  
  93.     if (this->IsEmpty())
  94.         returnRect = rect;
  95.         
  96.     else if (rect.IsEmpty())
  97.         returnRect = *this;
  98.         
  99.     else {
  100.         returnRect.top = Min(top, rect.top);
  101.         returnRect.left = Min(left, rect.left);
  102.         returnRect.bottom = Max(bottom, rect.bottom);
  103.         returnRect.right = Max(right, rect.right);
  104.     }
  105.     
  106.     return returnRect; 
  107. }
  108.  
  109.  
  110. //---------------------------------------------------------------
  111. //
  112. // TRect::operator&
  113. //
  114. //---------------------------------------------------------------
  115. TRect TRect::operator&(const TRect& rect) const
  116. {
  117.     TRect returnRect;
  118.     
  119.     returnRect.top = Max(top, rect.top);
  120.     returnRect.left = Max(left, rect.left);
  121.     returnRect.bottom = Min(bottom, rect.bottom);
  122.     returnRect.right = Min(right, rect.right);
  123.     
  124.     if (left > right || top > bottom)
  125.         returnRect = kZeroRect;
  126.     
  127.     return returnRect;
  128. } 
  129.  
  130.  
  131. //---------------------------------------------------------------
  132. //
  133. // TRect::MapTo
  134. //
  135. //---------------------------------------------------------------
  136. void TRect::MapTo(const TRect& container, double maxScaleFactor)
  137. {    
  138.     ASSERT(maxScaleFactor > 0.0);
  139.     
  140.     short srcHeight = this->GetHeight();
  141.     short srcWidth  = this->GetWidth();
  142.  
  143.     short destHeight = container.GetHeight();
  144.     short destWidth  = container.GetWidth();
  145.  
  146.     double    heightScale    = (double) destHeight/srcHeight;
  147.     double    widthScale    = (double) destWidth/srcWidth;
  148.     double    scale        = (widthScale < heightScale) ? widthScale : heightScale;
  149.     double    maxScale    = sqrt(maxScaleFactor);
  150.  
  151.     if (scale > maxScale)
  152.         scale = maxScale;
  153.  
  154.     short aspectHeight = (short) (srcHeight*scale + 0.5);
  155.     short aspectWidth  = (short) (srcWidth*scale + 0.5);
  156.  
  157.     ASSERT(aspectHeight <= destHeight);
  158.     ASSERT(aspectWidth <= destWidth);
  159.  
  160.     top     = (short) ((container.top + container.bottom - aspectHeight)/2);
  161.     left = (short) ((container.left + container.right - aspectWidth)/2);
  162.  
  163.     bottom = (short) (top + aspectHeight);
  164.     right  = (short) (left + aspectWidth);
  165. }
  166.  
  167.  
  168. //---------------------------------------------------------------
  169. //
  170. // TRect::Pin
  171. //
  172. //---------------------------------------------------------------
  173. TPoint TRect::Pin(const TPoint& pt) const
  174. {
  175.     TPoint result = pt;
  176.     
  177.     if (result.h < left)
  178.         result.h = left;
  179.     else if (result.h > right)
  180.         result.h = right;
  181.     
  182.     if (result.v < top)
  183.         result.v = top;
  184.     else if (result.v > bottom)
  185.         result.v = bottom;
  186.     
  187.     return result;
  188. }
  189.  
  190. #pragma mark -
  191.  
  192. // ===================================================================================
  193. //    class TLongPoint
  194. // ===================================================================================
  195.  
  196. //---------------------------------------------------------------
  197. //
  198. // TLongPoint::operator*
  199. //
  200. //---------------------------------------------------------------
  201. TLongPoint operator*(long num, const TLongPoint& pt)
  202. {
  203.     return TLongPoint(pt.h*num, pt.v*num);
  204. }
  205.  
  206.  
  207. // ===================================================================================
  208. //    class TLongSize
  209. // ===================================================================================
  210.  
  211. //---------------------------------------------------------------
  212. //
  213. // TLongSize::operator*
  214. //
  215. //---------------------------------------------------------------
  216. TLongSize operator*(long num, const TLongSize& size)
  217. {
  218.     return TLongSize(size.width*num, size.height*num);
  219. }
  220.  
  221. #pragma mark -
  222.  
  223. // ===================================================================================
  224. //    class TLongRect
  225. // ===================================================================================
  226.  
  227. //---------------------------------------------------------------
  228. //
  229. // TLongRect::operator|
  230. //
  231. //---------------------------------------------------------------
  232. TLongRect TLongRect::operator|(const TLongRect& rect) const
  233. {
  234.     TLongRect returnRect;
  235.  
  236.     if (this->IsEmpty())
  237.         returnRect = rect;
  238.         
  239.     else if (rect.IsEmpty())
  240.         returnRect = *this;
  241.         
  242.     else {
  243.         returnRect.top = Min(top, rect.top);
  244.         returnRect.left = Min(left, rect.left);
  245.         returnRect.bottom = Max(bottom, rect.bottom);
  246.         returnRect.right = Max(right, rect.right);
  247.     }
  248.     
  249.     return returnRect; 
  250. }
  251.  
  252.  
  253. //---------------------------------------------------------------
  254. //
  255. // TLongRect::operator&
  256. //
  257. //---------------------------------------------------------------
  258. TLongRect TLongRect::operator&(const TLongRect& rect) const
  259. {
  260.     TLongRect returnRect;
  261.     
  262.     returnRect.top = Max(top, rect.top);
  263.     returnRect.left = Max(left, rect.left);
  264.     returnRect.bottom = Min(bottom, rect.bottom);
  265.     returnRect.right = Min(right, rect.right);
  266.     
  267.     if (left > right || top > bottom)
  268.         returnRect = kLongZeroRect;
  269.     
  270.     return returnRect;
  271. } 
  272.  
  273.  
  274. //---------------------------------------------------------------
  275. //
  276. // TLongRect::MapTo
  277. //
  278. //---------------------------------------------------------------
  279. void TLongRect::MapTo(const TRect& container, double maxScaleFactor)
  280. {    
  281.     ASSERT(maxScaleFactor > 0.0);
  282.     
  283.     long srcHeight = this->GetHeight();
  284.     long srcWidth  = this->GetWidth();
  285.  
  286.     short destHeight = container.GetHeight();
  287.     short destWidth  = container.GetWidth();
  288.  
  289.     double    heightScale    = (double) destHeight/srcHeight;
  290.     double    widthScale    = (double) destWidth/srcWidth;
  291.     double    scale        = (widthScale < heightScale) ? widthScale : heightScale;
  292.     double    maxScale    = sqrt(maxScaleFactor);
  293.  
  294.     if (scale > maxScale)
  295.         scale = maxScale;
  296.  
  297.     long aspectHeight = (long) (srcHeight*scale + 0.5);
  298.     long aspectWidth  = (long) (srcWidth*scale + 0.5);
  299.  
  300.     ASSERT(aspectHeight <= destHeight);
  301.     ASSERT(aspectWidth <= destWidth);
  302.  
  303.     top     = (container.top + container.bottom - aspectHeight)/2;
  304.     left = (container.left + container.right - aspectWidth)/2;
  305.  
  306.     bottom = top + aspectHeight;
  307.     right  = left + aspectWidth;
  308. }
  309.  
  310.  
  311. //---------------------------------------------------------------
  312. //
  313. // TLongRect::Pin
  314. //
  315. //---------------------------------------------------------------
  316. TLongPoint TLongRect::Pin(const TLongPoint& pt) const
  317. {
  318.     TLongPoint result = pt;
  319.     
  320.     if (result.h < left)
  321.         result.h = left;
  322.     else if (result.h > right)
  323.         result.h = right;
  324.     
  325.     if (result.v < top)
  326.         result.v = top;
  327.     else if (result.v > bottom)
  328.         result.v = bottom;
  329.     
  330.     return result;
  331. }
  332.  
  333.